package com.datastructure.test.threeoftotal;

import java.util.*;

public class Solution {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int cityNum = in.nextInt();// 城市数目
        int[][] dist = new int[cityNum][cityNum];// 距离矩阵，距离为欧式空间距离
        for (int i = 0; i < dist.length; i++)
            for (int j = 0; j < cityNum; j++) {
                dist[i][j] = in.nextInt();
            }
        in.close();


        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();

        double res = 0;
        for(int i=1;i<=N;i++){
            res += sc.nextInt()*Math.pow(2, N - i);
        }
        System.out.println((int)Math.ceil(res/Math.pow(2, N)));

//        5
//        1 2 3 3 5
//        3
//        1 2 1
//        2 4 5
//        3 5 3
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        int[] fav=new int[n];
        for(int i=0;i<n;i++){
            fav[i]=scan.nextInt();
        }
        Map<Integer, List<Integer>> map=new HashMap<>();
        for(int i=0;i<n;i++){
            int key=fav[i];
            int value=i+1;
            if(!map.containsKey(key)){
                List<Integer> list=new LinkedList<>();
                list.add(value);
                map.put(key,list);
            }else{
                List<Integer> list=map.get(key);
                list.add(value);
            }
        }
        int m=scan.nextInt();
        Queue<Integer> queue=new LinkedList<>();
        for(int i=0;i<m;i++){
            int lo=scan.nextInt();
            int hi=scan.nextInt();
            int des=scan.nextInt();
            List<Integer> list=map.get(des);
            int count=0;
            if(list!=null){
                for(Integer integer:list){
                    if(integer>=lo&&integer<=hi){
                        count++;
                    }
                }
            }

            queue.add(count);

        }
        for(Integer integer:queue){
            System.out.println(integer);
        }
//        1。建立用户关系映射表，用户和标签为常量，关系为映射。保存用户画像最好使用缓存，比如emem***d，同时后端要落地到DB；
//        2。有了内存缓存的话，访问速度自然会有提升，除此之外，还要提高缓存利用率，这样请求不会到DB去请求。
//        3。同时还要减少单机查询流量，将不同用户分配到不同的机器上，可以采用分布式，比如按照用户的地区，ID的号段进行分开，这样每个机器的请求都是独立的，可以命中缓存，提高系统的性能。
//        4。一致性哈希，保证结点变化后用户访问的机器不变，比如之前在一号机器访问的用户还是到一号机器。
//        1. 画像应存储在非关系型数据库中，根据CAP原理，为了高可用/大数据量时不得不分区，只能舍弃部分一致性，由于用户画像并非支付类的核心信心，可以容忍部分不一致性。
//        2. 为了高并发/低延迟，活跃用户的画像应当缓存在内存形数据库中，在各地做数据缓存
//        3. 大多数非关系型数据库支持单点故障可访问，在线机器扩容


//                3 6
//                .S#..E
//                .#.0..
//                ......
//        Scanner sc=new Scanner(System.in);
//        int n=sc.nextInt();
//        int m=sc.nextInt();
//        char[][] chas=new char[n][m];
//        // 人的起始位置S 以及箱子的位置
//        int startX=0,startY=0,boxX=0,boxY=0;
//        // 判断位置 ，即人要先找到箱子，再推着箱子往前走
//        for(int i=0;i&amp;lt;n;i++){
//            String string=sc.next();
//            for(int j=0;j&amp;lt;m;j++){
//                chas[i][j]=string.charAt(j);
//                if(chas[i][j]==&amp;#39;S&amp;#39;){
//                    startX=i;
//                    startY=j;
//                }
//                if(chas[i][j]==&amp;#39;0&amp;#39;){
//                    boxX=i;
//                    boxY=j;
//                }
//            }
//        }
//        System.out.println(solve(chas,startX,startY,boxX,boxY));
    }


    public static class Node{
        int px;  // 人的位置
        int py;
        int bx;  //箱子的位置
        int by;
        int step;  //从初始位置到现在节点所走的步数
        public Node(int px,int py,int bx,int by){
            this.px=px;
            this.py=py;
            this.bx=bx;
            this.by=by;
        }
    }


//    private static int solve(char[][] chas,int startX, int startY,int boxX,int boxY) {
//        Node start=new Node(startX, startY,boxX,boxY);
//        int n=chas.length;
//        int m=chas[0].length;
//        // iswalked四维数组，可以用来存储走过的路径以防重复。
//        int[][][][] iswalked=new int[n][m][n][m];
//        // 每个节点都有dir4个方向的移动，分别是  下右上左
//        int[][] movedir=new int[][]{{1,0},{0,1},{-1,0},{0,-1}};
//
//        Queue&amp;lt;Node&amp;gt; que=new LinkedList&amp;lt;&amp;gt;();  //利用队列实现BFS
//        start.step=0;
//        que.add(start);
//
//        //开始BFS广度搜索最短路径
//        while(!que.isEmpty()){
//            Node cur=que.poll();
//            int newBx=cur.bx;
//            int newBy=cur.by;
//            for(int i=0;i&amp;lt;4;i++){  // 向4个方向走
//
//                //人在箱子左边或右边
//                if(cur.px==cur.bx){
//
//                    if (cur.py+movedir[i][1]==cur.by){
//                        newBy = cur.by+movedir[i][1];
//                    }else{
//                        newBy = cur.by;
//                    }
//
//                }
//
//                //人在箱子上面或下面
//                if(cur.py==cur.by){
//                    if(cur.px+movedir[i][0]==cur.bx){
//                        newBx = cur.bx+movedir[i][0];
//                    }else{
//                        newBx = cur.bx;
//                    }
//                }
//
//
//                // 箱子找到了要随人往4个方向动；没找到则箱子不动人动
//                Node next=new Node(cur.px+movedir[i][0], cur.py+movedir[i][1],newBx,newBy);
//                //不能让人在没找到箱子之前出地图或者自己提前到目的地
//                if(next.px&amp;lt;0||next.px&amp;gt;=n||next.py&amp;lt;0||next.py&amp;gt;=m||chas[next.px][next.py]==&amp;#39;#&amp;#39;
//                        ||next.bx&amp;lt;0||next.bx&amp;gt;=n||next.by&amp;lt;0||next.by&amp;gt;=m
//                        ||chas[next.bx][next.by]==&amp;#39;#&amp;#39;){
//                    continue;
//                }
//
//                // 0说明这条路径没有走过
//                if(iswalked[next.px][next.py][next.bx][next.by]==0){
//                    iswalked[next.px][next.py][next.bx][next.by]=1;
//                    next.step=cur.step+1;
//                    if(chas[next.bx][next.by]==&amp;#39;E&amp;#39;){   //此时把箱子推到终点了
//                        return next.step;  // 最先到终点的就是最短路径
//                    }
//                    que.add(next);
//                }
//            }
//        }
//        return -1;
//    }
    public int compareVersion (String version1, String version2) {
        // write code here
        String[] split = version1.split("\\.");
        String[] split1 = version2.split("\\.");
        int result=0;
        int length = Math.max(split.length,split1.length);
        for (int i = 0; i < length; i++) {
            if(Integer.parseInt(split[i])>Integer.parseInt(split1[i])){
                result=1;
                break;
            }else if(Integer.parseInt(split[i])<Integer.parseInt(split1[i])) {
                result=-1;

            }else if(Integer.parseInt(split[i])==Integer.parseInt(split1[i])) {
                result=0;
            }
        }
        return result;
    }
}
